import java.util.*;

public class TestDemo8B {
    public static void main1(String[] args) {
        int i=0;
        for(i=2;i<=10;i++){
            System.out.println(i);
        }
    }

    public static boolean canJump(int[] nums) {
        int maxjump=0;//代表跳的最长的长度(长度是以0下标开始往后跳的长度)
        for(int i=0;i<nums.length;i++){
            if(i<=maxjump){//不满足说明不能跳过数组最后一个下标
                //nums[i]+i代表跳的总长度(长度是以0下标开始往后跳的长度)
                maxjump=Math.max(maxjump,nums[i]+i);
                if(maxjump>=nums.length-1){//代表着可以跳过,返回
                    return true;
                }
            }
        }
        return false;
    }

    public static void main(String[] args) {
        int []nums={0};
        System.out.println(canJump(nums));
    }

    public boolean searchMatrix(int[][] matrix, int target) {
        int row=matrix.length;//行长度
        int lie=matrix[0].length;//列的长度
        int left=0;
        int right=row*lie-1;
        while(left<=right){
            int mid=(left+right)/2;//一维数组中间下标
            //把一维数组下标转成二维数组下标的值
            int midnum=matrix[mid/lie][mid%lie];
            if(midnum>target){
                right=mid-1;
            }else if(midnum<target){
                left=mid+1;
            }else{
                return true;
            }
        }
        return false;
    }
//长度最小的子数组
    public int minSubArrayLen(int target, int[] nums) {
        if(nums==null||nums.length==0){
            return 0;
        }
        //记录连续序列和的长度,初始化必须为nums.length+1才能找到最小
        int result=nums.length+1;
        int i=0;//记录连续序列和的起始下标
        int j=0;//
        int sum=0;
        while(j<nums.length){
            sum+=nums[j];
            while(sum>=target){//注意要为while因为可能,减去一个起始下标的值,后面的下标i的值也满足
                result=Math.min(result,j-i+1);
                sum-=nums[i];//找到了第一个直接减去起始下标的值,寻找下一个
                i++;
            }
            j++;
        }
        if(result==nums.length+1){//说明没有进入sum>=target循环,没有存在满足连续序列的和
            return 0;
        }
        return result;
    }
    //定长子串中元音的最大数目
    public int maxVowels(String s, int k) {
        if(s==null||s.length()==0||s.length()<k){
            return 0;
        }
        Set<Character> set=new HashSet<>();
        set.add('a');
        set.add('e');
        set.add('i');
        set.add('o');
        set.add('u');
        char[]ch=s.toCharArray();
        int count=0;//记录k长度下元音的个数
        int i=0;
        int result=0;//记录k长度下最多的元音个数
        while(i<k){//记录前k个长度下元音个数
            if(set.contains(ch[i])){
                count++;
            }
            i++;
        }
        result=Math.max(result,count);//记录最多元音个数
        for(i=k;i<ch.length;i++){
            //看k长度下起始位置是不是元音(去掉首位置的情况),是就减去一次
            if(set.contains(ch[i-k])){
                count--;
            }//看k后面的长度是不是元音(加上后位置的情况),就++
            if(set.contains(ch[i])){
                count++;
            }
            result=Math.max(result,count);
        }
        return result;
    }

    public static void main5(String[]args){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        String []str=new String[n+1];
        for(int i=0;i<n;i++){
            str[i]=sc.next();
        }
        if(zidian(str)&&zifuLength(str)){
            System.out.print("both");
        }else if(zidian(str)){
            System.out.print("lexicographically");
        }
        else if(zifuLength(str)){
            System.out.print("lengths");
        }else{
            System.out.print("none");
        }
    }
    public static boolean zifuLength(String[] str){
        for(int i=0;i<str.length-1;i++){
            if(str[i].length()>str[i+1].length()){
                return false;
            }
        }
        return true;
    }
    public static boolean zidian(String[]str  ){
        for(int i=0;i<str.length-1;i++){
            if(str[i].charAt(0)>str[i+1].charAt(0)){
                return false;
            }
        }
        return true;
    }
    //救生艇(双指针)-对撞指针
    public int numRescueBoats(int[] people, int limit) {
        Arrays.sort(people);
        int i=0;
        int j=people.length-1;
        int count=0;
        //不管满不满足j都要j--(题目要求),救生艇也要加一次
        while(i<=j){
            if(people[i]+people[j]<=limit){
                i++;
            }
            j--;
            count++;
        }
        return count;
    }

    public int jump(int[] nums) {
        // 贪心: 每次跳最远 -> 步数就最少
        int mostLength = 0;// 指向能跳跃到的最远下标
        int count = 0;// 记录跳跃次数
        int flg = 0;// 标记是否经过最远距离下标
        for (int i = 0; i < nums.length-1; i++){
            // 始终让mostLength指向最远能跳到的下标
            mostLength = Math.max(mostLength,nums[i]+i);
            // 如果i=flg 表示跳跃了一次
            if(i == flg){//下标为o时,一定要跳一次,这一次跳记录最远下标
                //经过最远下标就再算一次
                // 更新flg能到的位置
                flg = mostLength;
                // 记录次数
                count++;
            }
        }
        return count;
    }

    //括号生成
    public List<String> generateParenthesis(int n){
        List<String>result=new ArrayList<>();
        backtracking(n,result,0,0,"");
        return result;
    }

    private void backtracking(int n, List<String> result, int left, int right, String str) {
        if(left<right){
            return ;
        }
        if(left==n&&right==n){
            result.add(str);
            return ;
        }
        if(left<n){
            backtracking(n,result,left+1,right,str+"(");
        }
        if(left>right){
            backtracking(n,result,left,right+1,str+")");
        }
    }
}
